package com.ehotting.edsta.circuitDesign.bean;

import com.alibaba.fastjson.annotation.JSONField;
import lombok.Data;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;

public class CircuitPropertyBean{

    /**
     * 传感电路属性
     */
    private List<CircuitBean> sensorCircuitListBean = new ArrayList<>();
    /**
     * 处理器电路属性
     */
    private List<CircuitBean> controllerCircuitListBean = new ArrayList<>();
    /**
     * 电源电路属性
     */
    private List<CircuitBean> powerCircuitListBean = new ArrayList<>();

    public List<CircuitBean> getSensorCircuitListBean() {
        return sensorCircuitListBean;
    }

    public void setSensorCircuitListBean(List<CircuitBean> sensorCircuitListBean) {
        this.sensorCircuitListBean = sensorCircuitListBean;
    }

    public List<CircuitBean> getControllerCircuitList() {
        return controllerCircuitListBean;
    }

    public void setControllerCircuitList(List<CircuitBean> controllerCircuitListBean) {
        this.controllerCircuitListBean = controllerCircuitListBean;
    }

    public List<CircuitBean> getPowerCircuitList() {
        return powerCircuitListBean;
    }

    public void setPowerCircuitList(List<CircuitBean> powerCircuitListBean) {
        this.powerCircuitListBean = powerCircuitListBean;
    }

    public static class CircuitBean {
        /**
         * id
         */
        private Long id;
        /**
         * 电路类型
         */
        private String type;
        /**
         * 电路名称
         */
        private String name;
        /**
         * 电路属性
         */
        private Map<String, PropertyBean> propertyMap;

        public Long getId() {
            return id;
        }

        public void setId(Long id) {
            this.id = id;
        }

        public String getType() {
            return type;
        }

        public void setType(String type) {
            this.type = type;
        }

        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }

        public Map<String, PropertyBean> getPropertyMap() {
            return propertyMap;
        }

        public void setPropertyMap(Map<String, PropertyBean> propertyMap) {
            this.propertyMap = propertyMap;
        }
    }

    public static class PropertyBean {
        /**
         * 属性编码
         */
        private String code;
        /**
         * 属性名称
         */
        private String name;
        /**
         * 属性值
         */
        private String value;
        /**
         * 数据类型
         */
        private String dataType;

        public String getCode() {
            return code;
        }

        public void setCode(String code) {
            this.code = code;
        }

        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }

        public String getValue() {
            return value;
        }

        public void setValue(String value) {
            this.value = value;
        }

        public String getDataType() {
            return dataType;
        }

        public void setDataType(String dataType) {
            this.dataType = dataType;
        }
    }

    public static class ParamTipsList{
        private List<Data> dataList;

        public List<Data> getDataList() {
            return dataList;
        }

        public void setDataList(List<Data> dataList) {
            this.dataList = dataList;
        }
    }

    public static class Data{

        /**
         * 数据采集电路
         * 数据处理电路
         * 电源电路
         * 质量等级-质量等级（属性）
         * 结构：List
         * 匹配：包含
         * ok
         */
        @JSONField(name = "qualitygrade")
        private String qualitygrade;


        /**
         ------------------------------------ 模拟电路---------------------------------
         */

        /**
         * 数据采集电路（模拟）
         * 采集类型-采集信号类（实体）
         * 结构：List
         * 匹配：相等
         * ok
         */
        @JSONField(name = "analoguetype")
        private String signalType;


        /**
         * 数据采集电路（模拟）
         * 最大频率-信号带宽（属性）
         * 结构：单值最大值
         * 匹配：多值范围（难点）
         * ok
         */
        @JSONField(name = "signalmax")
        private String fMax;


        /**
         * 数据采集电路（模拟）
         * 最小频率-信号带宽（属性）
         * 结构：List，两个值，最小和最大值
         * 匹配：多值范围（难点）
         * ok
         */
        @JSONField(name = "signalmin")
        private String fMin;


        /**
         * 数据采集电路（模拟）
         * 最大输入范围-数据范围（属性）
         * 结构：单值最大值
         * 匹配：多值范围（难点）
         * ok
         */
        @JSONField(name = "maxdatarange")
        private String inputMaxRange;


        /**
         * 数据采集电路（模拟）
         * 最小输入范围-数据范围（属性）
         * 结构：List，两个值，最小和最大值
         * 匹配：多值范围（难点）
         * ok
         * 做法：拿所有电路的最小和最大值，返回给前端提示
         * 当输入第一个值（最小值输入框）时，拿这个值去找大于等于最小值的电路，返回找出电路的最大值给前端，
         * 当输入第二个值（最大值输入框）时，拿最小和最大值去找电路符合的范围；
         */
        @JSONField(name = "mindatarange")
        private String inputMinRange;


        /**
         * 数据采集电路（模拟）
         * 采样率-采样率（属性）
         * 结构：单值最大值
         * 匹配：单值范围
         * 做法：返回一个最大输入限制，
         * 拿到输入值后，找出大于等于输入值的电路
         * ok
         */
        @JSONField(name = "sample")
        private String sample;


        /**
         * 数据采集电路（模拟）
         * ADC分辨率-采样分辨率（属性）
         * 结构：List
         * 匹配：单值范围
         * 做法：返回多个值，
         * 拿到输入值后，找出大于等于输入值的电路
         */
        @JSONField(name = "samplingbit")
        private String adcSamplingBit;


        /**
         * 数据采集电路（模拟）
         * 存储长度-采样长度（属性）
         * 结构：List
         * 不匹配
         */
        @JSONField(name = "samplinglength")
        private String samplingLength;



         /**
         ------------------------------------ 数字电路---------------------------------
         */

        /**
         * 数据采集电路（数字）
         * 数字电路类型-数字信号输入类型（属性）
         * 结构：List
         * 匹配：相等
         * ok
         */
        @JSONField(name = "intype")
        private String inType;


        /**
         * 数据采集电路（数字）
         * 输入端电压范围-输入信号电压（属性）
         * 结构：List，两个值，最小和最大值
         * 匹配：多值范围（难点）
         * 做法：找出最小和最大值，返回前端，如果有单值，最小值是0，如有范围值，从范围值里提取最小值，
         * 最大值取范围和单值的最大值
         * 不做条件筛选，只返回数据
         */
        @JSONField(name = "involt")
        private String inputVoltageRange;



        /**
         ------------------------------------ 处理器电路---------------------------------
         */

        /**
         * 数据处理电路
         * 总线通信类型-总线通信类型（属性）
         * 结构：List
         * 匹配：相等
         * ok
         */
        @JSONField(name = "bus")
        private String cpuInterface;


        /**
         * 数据处理电路
         * 处理器类型-处理器的类型（属性）
         * 结构：List
         * 匹配：相等
         * ok
         */
        @JSONField(name = "controller")
        private String controller;




        /**
         ------------------------------------ 电源电路---------------------------------
         */

        /**
         * 电源电路
         * 电压等级-电压等级（属性）
         * 结构：List，多个电压等级，去掉属性的逗号分隔
         * 匹配：包含，判断电路属性是否包括输入值
         * ok
         */
        @JSONField(name = "volt")
        private String inVoltage;

        /**
         * 电源电路
         * 最大功率-最大功率（属性）
         * 结构：List，两个值，最小和最大值
         * 匹配：单值范围
         * 做法：找出小于输入值的电路
         * ok
         */
        @JSONField(name = "power")
        private String maxPower;


        /**
         * 第几页参数
         */
        @JSONField(name = "page")
        private String page;

        public String getPage() {
            return page;
        }

        public void setPage(String page) {
            this.page = page;
        }

        public String getQualitygrade() {
            return qualitygrade;
        }

        public void setQualitygrade(String qualitygrade) {
            this.qualitygrade = qualitygrade;
        }

        public String getSignalType() {
            return signalType;
        }

        public void setSignalType(String signalType) {
            this.signalType = signalType;
        }

        public String getfMax() {
            return fMax;
        }

        public void setfMax(String fMax) {
            this.fMax = fMax;
        }

        public String getfMin() {
            return fMin;
        }

        public void setfMin(String fMin) {
            this.fMin = fMin;
        }

        public String getInputMaxRange() {
            return inputMaxRange;
        }

        public void setInputMaxRange(String inputMaxRange) {
            this.inputMaxRange = inputMaxRange;
        }

        public String getInputMinRange() {
            return inputMinRange;
        }

        public void setInputMinRange(String inputMinRange) {
            this.inputMinRange = inputMinRange;
        }

        public String getSample() {
            return sample;
        }

        public void setSample(String sample) {
            this.sample = sample;
        }

        public String getAdcSamplingBit() {
            return adcSamplingBit;
        }

        public void setAdcSamplingBit(String adcSamplingBit) {
            this.adcSamplingBit = adcSamplingBit;
        }

        public String getSamplingLength() {
            return samplingLength;
        }

        public void setSamplingLength(String samplingLength) {
            this.samplingLength = samplingLength;
        }

        public String getInType() {
            return inType;
        }

        public void setInType(String inType) {
            this.inType = inType;
        }

        public String getInputVoltageRange() {
            return inputVoltageRange;
        }

        public void setInputVoltageRange(String inputVoltageRange) {
            this.inputVoltageRange = inputVoltageRange;
        }

        public String getCpuInterface() {
            return cpuInterface;
        }

        public void setCpuInterface(String cpuInterface) {
            this.cpuInterface = cpuInterface;
        }

        public String getController() {
            return controller;
        }

        public void setController(String controller) {
            this.controller = controller;
        }

        public String getInVoltage() {
            return inVoltage;
        }

        public void setInVoltage(String inVoltage) {
            this.inVoltage = inVoltage;
        }

        public String getMaxPower() {
            return maxPower;
        }

        public void setMaxPower(String maxPower) {
            this.maxPower = maxPower;
        }
    }

    public enum PropertyEnum{
        QUALITYGRADE("qualitygrade","质量等级"),
        SIGNALTYPE("signalType","采集类型"),
        FMAX("fMax","最大频率"),
        FMIN("fMin","最小频率"),
        INPUTMAXRANGE("inputMaxRange","最大输入范围"),
        INPUTMINRANGE("inputMinRange","最小输入范围"),
        SAMPLE("sample","采样率"),
        ADCSAMPLINGBIT("numberOfDigits","采样分辨率"),
        INTYPE("inType","数字电路类型"),
        INPUTVOLTAGERANGE("inputVoltageRange","输入信号电压"),
        CPUINTERFACE("cpuInterface","总线通信类型"),
        CONTROLLER("controller","处理器的类型"),
        INVOLTAGE("inVoltage","电压等级"),
        MAXPOWER("maxPower","最大功率"),
        OUTPUTTYPE("outputType","输出类型"),
        SOURCE("source","来源");


        private String code;
        private String name;

        PropertyEnum(String code, String name) {
            this.code = code;
            this.name = name;
        }


        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }

        public String getCode() {
            return code;
        }

        public void setCode(String code) {
            this.code = code;
        }

    }

}
